use std::{io, usize};

use tokio::net::{ TcpListener};
use std::net::{TcpListener as StdTcpListener, SocketAddr};

use anyhow::{Ok, Result};
use tracing::{info, warn};

use socket2::{Socket, Domain, Type};

const BUF_SIZE: usize = 4096;

#[tokio::main]
async fn main() -> Result<()>{
    //println!("Hello world!");
    // build a listener
    tracing_subscriber::fmt::init();


    let addr  = "0.0.0.0:6379".parse::<SocketAddr>()?;
    // let addr = "0.0.0.0:6378".parse::<SocketAddr>()?;
    // // TcpListener  在std::net 下也有， 但会报错， 说是没有impl  Future
    // info!("start to connect {}", addr);
    
    
    let listener = StdTcpListener::bind(addr)?;
    info!("dredis listenning on {}", addr);

    // let addr = "0.0.0.0:6379".parse::<SocketAddr>()?;
    // let std_listener = StdTcpListener::bind(&addr)?;
    // std_listener.set_nonblocking(true)?; // Required for Tokio
    
    // std_listener.set_reuse_address(true)?; // Enable SO_REUSEADDR

    // let listener = TcpListener::from_std(std_listener)?;

    // let socket = Socket::new(Domain::IPV4, Type::STREAM, None)?;
    
    // // Set SO_REUSEADDR
    // socket.set_reuse_address(true)?;
    
    // // Bind the socket to the address
    // socket.bind(&addr.into())?;
    
    // // Listen for connections
    // socket.listen(128)?;

    // // Convert to std::net::TcpListener
    // let std_listener: StdTcpListener = socket.into();
    
    // // Set non-blocking mode (required for Tokio)
    // std_listener.set_nonblocking(true)?;
    
    // // Convert to Tokio TcpListener
    // let listener = TcpListener::from_std(std_listener)?;
    
    info!("Listening on {}", addr);
    Ok(())

    // loop{
    //     let (stream, raddr) = listener.accept().await?;
    //     info!("acccepted connection from {}", raddr);

    //     tokio::spawn(async move {
    //        if let Err(e) = process_redis_conn(stream).await {
    //         warn!("Error processing conn with {}: {:?}",raddr, e);
    //        }
    //     });
    // }
}


// async fn process_redis_conn(stream: tokio::net::TcpStream) -> Result<()>{
//     loop {
//         stream.readable().await?;  // 保证stream 是可读的， 它还有什么状态， 没有数据吗
//         let mut buf: Vec<u8> = Vec::with_capacity(BUF_SIZE);
        
//      //   let mut buf  = [0 as u16;4096];
//         match stream.try_read(&mut buf) {
//              Ok(0) => break,
//             Ok(n) => {info!("read {} bytes",n);
//                 let line = String::from_utf8_lossy(&buf);
//                 info!("{}",line);

//                let _ = stream.try_write(b"+Ok\r\n");  // 每次接到数据， 都返回一个ok
//                 }
//             Err(e) if e.kind() == io::ErrorKind::WouldBlock => {
//                 continue;
//             },

//             Err(e)=>{
//                 return Err(e.into());
//             }
//         }

//     }
//     Ok(())
// }